{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:38:48.014904Z",
     "iopub.status.busy": "2022-01-02T19:38:48.014055Z",
     "iopub.status.idle": "2022-01-02T19:39:28.910347Z",
     "shell.execute_reply": "2022-01-02T19:39:28.909695Z",
     "shell.execute_reply.started": "2022-01-02T18:26:51.63521Z"
    },
    "papermill": {
     "duration": 40.929307,
     "end_time": "2022-01-02T19:39:28.910471",
     "exception": false,
     "start_time": "2022-01-02T19:38:47.981164",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.6.0\r\n",
      "10.2\r\n",
      "\u001b[33mWARNING: You are using pip version 20.2.4; however, version 21.3.1 is available.\r\n",
      "You should consider upgrading via the '/opt/conda/bin/python3.7 -m pip install --upgrade pip' command.\u001b[0m\r\n",
      "\u001b[33mWARNING: You are using pip version 20.2.4; however, version 21.3.1 is available.\r\n",
      "You should consider upgrading via the '/opt/conda/bin/python3.7 -m pip install --upgrade pip' command.\u001b[0m\r\n"
     ]
    }
   ],
   "source": [
    "!python -c \"import torch; print(torch.__version__)\"\n",
    "!python -c \"import torch; print(torch.version.cuda)\"\n",
    "!pip -q install torch-spline-conv==latest+cu102 torch-scatter==latest+cu102 torch-cluster==latest+cu102 torch-sparse==latest+cu102  -f https://pytorch-geometric.com/whl/torch-1.6.0.html\n",
    "\n",
    "!pip install -q git+https://github.com/elmahyai/pytorch_geometric_temporal   # remove after merging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.020249,
     "end_time": "2022-01-02T19:39:28.951508",
     "exception": false,
     "start_time": "2022-01-02T19:39:28.931259",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "<h1>\n",
    "<center>Attention Based Spatial-Temporal Graph Convolutional Networks\n",
    "for Traffic Flow Forecasting</center>\n",
    "</h1>\n",
    "\n",
    "In this notebook we will dive into attentional temporal graph convolution networks where everything new meets Attention + deep learning time series analysis( temporal data) + Graph convolution all in one thing. This is a rewriting of the code of the paper (Attention Based Spatial-Temporal Graph Convolutional Networks for Traffic Flow Forecasting https://ojs.aaai.org/index.php/AAAI/article/view/3881 ), from which we will include quotes and parts of their code. This notebook uses the data prepared in the previous notebook (Processing traffic data for deep learning projects)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:39:29.002973Z",
     "iopub.status.busy": "2022-01-02T19:39:29.002190Z",
     "iopub.status.idle": "2022-01-02T19:39:36.720940Z",
     "shell.execute_reply": "2022-01-02T19:39:36.719759Z",
     "shell.execute_reply.started": "2022-01-02T18:27:31.17286Z"
    },
    "papermill": {
     "duration": 7.749484,
     "end_time": "2022-01-02T19:39:36.721075",
     "exception": false,
     "start_time": "2022-01-02T19:39:28.971591",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CUDA: True cuda:0\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from time import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "\n",
    "\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "USE_CUDA = torch.cuda.is_available()\n",
    "DEVICE = torch.device('cuda:0')\n",
    "print(\"CUDA:\", USE_CUDA, DEVICE)\n",
    "\n",
    "from tensorboardX import SummaryWriter\n",
    "sw = SummaryWriter(logdir='.', flush_secs=5)\n",
    "\n",
    "import math\n",
    "from typing import Optional, List, Union\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn import Parameter\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from torch_geometric.data import Data\n",
    "from torch_geometric.typing import OptTensor\n",
    "from torch_geometric.nn.conv import MessagePassing\n",
    "from torch_geometric.transforms import LaplacianLambdaMax\n",
    "from torch_geometric.utils import remove_self_loops, add_self_loops, get_laplacian\n",
    "from torch_geometric.utils import to_dense_adj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.022775,
     "end_time": "2022-01-02T19:39:36.766042",
     "exception": false,
     "start_time": "2022-01-02T19:39:36.743267",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Loading data  ( The temporal part) \n",
    "As discussed in the previous notebook, the data is splitted as follows:\n",
    "\n",
    "10181 data/target examples will be used as the training set ( 35 days )\n",
    "\n",
    "3394 data/target examples will be used as the validation set (12 days)\n",
    "\n",
    "3394 data/target examples will be used as the testing set (12 days)\n",
    "\n",
    "The shape for each prediction / target hour example is  (12, 307, 3)  , As the data will be loaded in batches of size 32 \n",
    "\n",
    "its shape will be (32, 12, 307, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:39:36.863370Z",
     "iopub.status.busy": "2022-01-02T19:39:36.862403Z",
     "iopub.status.idle": "2022-01-02T19:39:36.901342Z",
     "shell.execute_reply": "2022-01-02T19:39:36.902597Z",
     "shell.execute_reply.started": "2022-01-02T18:27:38.701215Z"
    },
    "papermill": {
     "duration": 0.097144,
     "end_time": "2022-01-02T19:39:36.902795",
     "exception": false,
     "start_time": "2022-01-02T19:39:36.805651",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def load_graphdata_channel1(graph_signal_matrix_filename, num_of_hours, num_of_days, num_of_weeks, batch_size,\n",
    "                            shuffle=True, DEVICE = torch.device('cuda:0')):\n",
    "    '''\n",
    "    :param graph_signal_matrix_filename: str\n",
    "    :param num_of_hours: int\n",
    "    :param num_of_days: int\n",
    "    :param num_of_weeks: int\n",
    "    :param DEVICE:\n",
    "    :param batch_size: int\n",
    "    :return:\n",
    "    three DataLoaders, each dataloader contains:\n",
    "    test_x_tensor: (B, N_nodes, in_feature, T_input)\n",
    "    test_decoder_input_tensor: (B, N_nodes, T_output)\n",
    "    test_target_tensor: (B, N_nodes, T_output)\n",
    "    '''\n",
    "\n",
    "    file = os.path.basename(graph_signal_matrix_filename).split('.')[0]\n",
    "    filename = os.path.join('../input/processing-traffic-data-for-deep-learning-projects/', file + '_r' + str(num_of_hours) + '_d' + str(num_of_days) + '_w' + str(num_of_weeks)) +'_astcgn'\n",
    "    print('load file:', filename)\n",
    "\n",
    "    file_data = np.load(filename + '.npz')\n",
    "    train_x = file_data['train_x']  # (10181, 307, 3, 12)\n",
    "    train_x = train_x[:, :, 0:1, :]\n",
    "    train_target = file_data['train_target']  # (10181, 307, 12)\n",
    "\n",
    "    val_x = file_data['val_x']\n",
    "    val_x = val_x[:, :, 0:1, :]\n",
    "    val_target = file_data['val_target']\n",
    "\n",
    "    test_x = file_data['test_x']\n",
    "    test_x = test_x[:, :, 0:1, :]\n",
    "    test_target = file_data['test_target']\n",
    "\n",
    "    mean = file_data['mean'][:, :, 0:1, :]  # (1, 1, 3, 1)\n",
    "    std = file_data['std'][:, :, 0:1, :]  # (1, 1, 3, 1)\n",
    "\n",
    "    # ------- train_loader -------\n",
    "    train_x_tensor = torch.from_numpy(train_x).type(torch.FloatTensor).to(DEVICE)  # (B, N, F, T)\n",
    "    train_target_tensor = torch.from_numpy(train_target).type(torch.FloatTensor).to(DEVICE)  # (B, N, T)\n",
    "    train_dataset = torch.utils.data.TensorDataset(train_x_tensor, train_target_tensor)\n",
    "    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle)\n",
    "\n",
    "    # ------- val_loader -------\n",
    "    val_x_tensor = torch.from_numpy(val_x).type(torch.FloatTensor).to(DEVICE)  # (B, N, F, T)\n",
    "    val_target_tensor = torch.from_numpy(val_target).type(torch.FloatTensor).to(DEVICE)  # (B, N, T)\n",
    "    val_dataset = torch.utils.data.TensorDataset(val_x_tensor, val_target_tensor)\n",
    "    val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "    # ------- test_loader -------\n",
    "    test_x_tensor = torch.from_numpy(test_x).type(torch.FloatTensor).to(DEVICE)  # (B, N, F, T)\n",
    "    test_target_tensor = torch.from_numpy(test_target).type(torch.FloatTensor).to(DEVICE)  # (B, N, T)\n",
    "    test_dataset = torch.utils.data.TensorDataset(test_x_tensor, test_target_tensor)\n",
    "    test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "    # print\n",
    "    print('train:', train_x_tensor.size(), train_target_tensor.size())\n",
    "    print('val:', val_x_tensor.size(), val_target_tensor.size())\n",
    "    print('test:', test_x_tensor.size(), test_target_tensor.size())\n",
    "\n",
    "    return train_loader, train_target_tensor, val_loader, val_target_tensor, test_loader, test_target_tensor, mean, std\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:39:36.979221Z",
     "iopub.status.busy": "2022-01-02T19:39:36.978413Z",
     "iopub.status.idle": "2022-01-02T19:40:22.221316Z",
     "shell.execute_reply": "2022-01-02T19:40:22.221777Z",
     "shell.execute_reply.started": "2022-01-02T18:27:38.73126Z"
    },
    "papermill": {
     "duration": 45.287987,
     "end_time": "2022-01-02T19:40:22.221921",
     "exception": false,
     "start_time": "2022-01-02T19:39:36.933934",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "load file: ../input/processing-traffic-data-for-deep-learning-projects/PEMS04_r1_d0_w0_astcgn\n",
      "train: torch.Size([10181, 307, 1, 12]) torch.Size([10181, 307, 12])\n",
      "val: torch.Size([3394, 307, 1, 12]) torch.Size([3394, 307, 12])\n",
      "test: torch.Size([3394, 307, 1, 12]) torch.Size([3394, 307, 12])\n"
     ]
    }
   ],
   "source": [
    "graph_signal_matrix_filename = '../input/pems-dataset/data/PEMS04/PEMS04.npz'\n",
    "batch_size = 32\n",
    "num_of_weeks = 0\n",
    "num_of_days = 0\n",
    "num_of_hours = 1\n",
    "\n",
    "train_loader, train_target_tensor, val_loader, val_target_tensor, test_loader, test_target_tensor, _mean, _std = load_graphdata_channel1(\n",
    "    graph_signal_matrix_filename, num_of_hours, num_of_days, num_of_weeks, batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.020698,
     "end_time": "2022-01-02T19:40:22.263490",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.242792",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Loading the graph ( The spatial part) \n",
    "\n",
    "In our case the graph is the Traffic Networks (literally, the network between the detectors (sensors) applied on the traffic networks\n",
    "\n",
    "In our example we have 307 detectors that when connected spatially, give our traffic network under investigation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:40:22.323933Z",
     "iopub.status.busy": "2022-01-02T19:40:22.322066Z",
     "iopub.status.idle": "2022-01-02T19:40:22.324599Z",
     "shell.execute_reply": "2022-01-02T19:40:22.325011Z",
     "shell.execute_reply.started": "2022-01-02T18:28:24.769891Z"
    },
    "papermill": {
     "duration": 0.039407,
     "end_time": "2022-01-02T19:40:22.325118",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.285711",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def get_adjacency_matrix(distance_df_filename, num_of_vertices, id_filename=None):\n",
    "    '''\n",
    "    Parameters\n",
    "    ----------\n",
    "    distance_df_filename: str, path of the csv file contains edges information\n",
    "    num_of_vertices: int, the number of vertices\n",
    "    Returns\n",
    "    ----------\n",
    "    A: np.ndarray, adjacency matrix\n",
    "    '''\n",
    "    if 'npy' in distance_df_filename:  # false\n",
    "        adj_mx = np.load(distance_df_filename)\n",
    "        return adj_mx, None\n",
    "    else:\n",
    "        \n",
    "        #--------------------------------------------- read from here\n",
    "        import csv\n",
    "        A = np.zeros((int(num_of_vertices), int(num_of_vertices)),dtype=np.float32)\n",
    "        distaneA = np.zeros((int(num_of_vertices), int(num_of_vertices)), dtype=np.float32)\n",
    "\n",
    "        #------------ Ignore\n",
    "        if id_filename: # false\n",
    "            with open(id_filename, 'r') as f:\n",
    "                id_dict = {int(i): idx for idx, i in enumerate(f.read().strip().split('\\n'))}  # 把节点id（idx）映射成从0开始的索引\n",
    "\n",
    "            with open(distance_df_filename, 'r') as f:\n",
    "                f.readline()\n",
    "                reader = csv.reader(f)\n",
    "                for row in reader:\n",
    "                    if len(row) != 3:\n",
    "                        continue\n",
    "                    i, j, distance = int(row[0]), int(row[1]), float(row[2])\n",
    "                    A[id_dict[i], id_dict[j]] = 1\n",
    "                    distaneA[id_dict[i], id_dict[j]] = distance\n",
    "            return A, distaneA\n",
    "\n",
    "        else:\n",
    "         #-------------Continue reading\n",
    "            with open(distance_df_filename, 'r') as f:\n",
    "                f.readline()\n",
    "                reader = csv.reader(f)\n",
    "                for row in reader:\n",
    "                    if len(row) != 3:\n",
    "                        continue\n",
    "                    i, j, distance = int(row[0]), int(row[1]), float(row[2])\n",
    "                    A[i, j] = 1\n",
    "                    distaneA[i, j] = distance\n",
    "            return A, distaneA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:40:22.373874Z",
     "iopub.status.busy": "2022-01-02T19:40:22.373374Z",
     "iopub.status.idle": "2022-01-02T19:40:22.750471Z",
     "shell.execute_reply": "2022-01-02T19:40:22.749939Z",
     "shell.execute_reply.started": "2022-01-02T18:28:24.790394Z"
    },
    "papermill": {
     "duration": 0.404466,
     "end_time": "2022-01-02T19:40:22.750585",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.346119",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "id_filename = None\n",
    "adj_filename = '../input/pems-dataset/data/PEMS04/PEMS04.csv'\n",
    "num_of_vertices = 307\n",
    "adj_mx, distance_mx = get_adjacency_matrix(adj_filename, num_of_vertices, id_filename) #  adj_mx and distance_mx (307, 307)\n",
    "\n",
    "rows, cols = np.where(adj_mx == 1)\n",
    "edges = zip(rows.tolist(), cols.tolist())\n",
    "gr = nx.Graph()\n",
    "gr.add_edges_from(edges)\n",
    "nx.draw(gr, node_size=3)\n",
    "plt.show()\n",
    "rows, cols = np.where(adj_mx == 1)\n",
    "edges = zip(rows.tolist(), cols.tolist())\n",
    "edge_index_data = torch.LongTensor(np.array([rows, cols])).to(DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.023484,
     "end_time": "2022-01-02T19:40:22.799782",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.776298",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Making the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.022939,
     "end_time": "2022-01-02T19:40:22.846081",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.823142",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Model Layers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.021699,
     "end_time": "2022-01-02T19:40:22.890144",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.868445",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Temporal attention layer\n",
    "\n",
    "In the temporal dimension, there exist correlations between the traffic conditions in different time slices, and the correlations are also varying under different situations. Likewise, we use an attention mechanism to adaptively attach different importance to data. \n",
    "\n",
    "<img src=\"https://i.ibb.co/KwXCqJx/temp-attention.png\" width=\"400\">\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.021848,
     "end_time": "2022-01-02T19:40:22.935135",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.913287",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "To understand the equation :\n",
    "\n",
    "It learns to attend (focus) on which part of the time segement used as input. In our case we have 12 time points So it will generate 12 by 12 weights. \n",
    "\n",
    "<img src=\"https://i.ibb.co/NZ4fh4k/atten2.jpg\" width=\"400\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.0216,
     "end_time": "2022-01-02T19:40:22.978912",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.957312",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Spatial attention layer\n",
    "\n",
    "In the spatial dimension, the traffic conditions of different locations have influence among each other and the mutual influence is highly dynamic. Here, we use an attention mechanism (Feng et al. 2017) to adaptively capture the dynamic correlations between nodes in the spatial dimension.\n",
    "\n",
    "<img src=\"https://i.ibb.co/PGnj4MR/spatial1.png\" width=\"400\">\n",
    "\n",
    "<img src=\"https://i.ibb.co/G5jkKvr/spatial2.png\" width=\"400\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.022913,
     "end_time": "2022-01-02T19:40:23.023944",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.001031",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "The same as with the temporal attention; however, here the attention weights will be used inside a Graph convolution layer\n",
    "\n",
    "\n",
    "\n",
    "<img src=\"https://i.ibb.co/stTfTFM/spat2.jpg\" width=\"400\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.02208,
     "end_time": "2022-01-02T19:40:23.068302",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.046222",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Spectral graph analysis on the spatial part\n",
    "Since the spatial part is represented as a graph, we will apply graph convolution to aggregate messages from neighbor nodes. The type of graph convolution that we are going to use is spectral convolution. \n",
    "\n",
    "* In spectral graph analysis, a graph is represented by its corresponding Laplacian matrix. \n",
    "* The properties of the graph structure can be obtained by analyzing Laplacian matrix and its eigenvalues\n",
    "\n",
    "* Laplacian matrix of a graph is defined as L = D − A, \n",
    "\n",
    "* Its normalized form is L = I − ((1/ sqrt(D) A ( 1/ sqrt(D))  \n",
    "\n",
    "where A is the adjacent matrix, I is a unit matrix, and the degree matrix D (diagnoal diagonal matrix, consisting of node degrees,at the diagonal) \n",
    "\n",
    "The eigenvalue decomposition of the Laplacian matrix is L = U*Λ*(U.transpose()) , where Λ = diag([λ0, ..., λN −1]) is a diagonal matrix, and U is Fourier basis. \n",
    "\n",
    "U is an orthogonal matrix.\n",
    "\n",
    "The graph convolution is a convolution operation implemented by using linear operators that diagonalize in the Fourier domain to replace the classical convolution operator.\n",
    "\n",
    "However, it is expensive to directly perform the eigenvalue decomposition on the Laplacian matrix when the scale of the graph is large. Therefore, Chebyshev polynomials are adopted to solve this problem approximately but efficiently. \n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.022081,
     "end_time": "2022-01-02T19:40:23.113054",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.090973",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "attachments": {
    "ec80c00c-6836-4449-85ba-e0b9d174a2f5.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.022314,
     "end_time": "2022-01-02T19:40:23.157536",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.135222",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# The ASTGCN model structure\n",
    "\n",
    "\n",
    "The model is composed of two ASTGCN blocks followed by a final layer\n",
    "\n",
    "Original x (input) is (32, 307, 1, 12) -Block1> (32, 307, 64, 12) -Block2> (32, 307, 64, 12) -permute-> (32, 12, 307,64) \n",
    "            # -final_conv-> (32, 12, 307, 1) -reshape-> (32,307,12) \"The target\"\n",
    "            \n",
    "\n",
    "\n",
    "The model is  the fusion of three independent components with the same structure, which are designed to respectively model the recent, daily-periodic and weekly-periodic dependencies of the historical data. This is discussed in the previous notebook (https://www.kaggle.com/elmahy/processing-traffic-data-for-deep-learning-projects). \n",
    "\n",
    "But in our case we will only focus on the recent segment (last hour segment) i.e. X_h  \n",
    "\n",
    "![astgcn.png](attachment:ec80c00c-6836-4449-85ba-e0b9d174a2f5.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:40:23.209853Z",
     "iopub.status.busy": "2022-01-02T19:40:23.208981Z",
     "iopub.status.idle": "2022-01-02T19:40:23.220512Z",
     "shell.execute_reply": "2022-01-02T19:40:23.220036Z",
     "shell.execute_reply.started": "2022-01-02T18:50:13.601941Z"
    },
    "papermill": {
     "duration": 0.04099,
     "end_time": "2022-01-02T19:40:23.220618",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.179628",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from torch_geometric_temporal.nn.attention import ASTGCN   # For information about the architecture check the source code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.021947,
     "end_time": "2022-01-02T19:40:23.264474",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.242527",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Initialized the ASTGCN model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:40:23.317027Z",
     "iopub.status.busy": "2022-01-02T19:40:23.316432Z",
     "iopub.status.idle": "2022-01-02T19:40:23.353140Z",
     "shell.execute_reply": "2022-01-02T19:40:23.352704Z",
     "shell.execute_reply.started": "2022-01-02T18:28:25.176855Z"
    },
    "papermill": {
     "duration": 0.066646,
     "end_time": "2022-01-02T19:40:23.353254",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.286608",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ASTGCN(\n",
      "  (_blocklist): ModuleList(\n",
      "    (0): ASTGCNBlock(\n",
      "      (_temporal_attention): TemporalAttention()\n",
      "      (_spatial_attention): SpatialAttention()\n",
      "      (_chebconv_attention): ChebConvAttention(1, 64, K=3, normalization=None)\n",
      "      (_time_convolution): Conv2d(64, 64, kernel_size=(1, 3), stride=(1, 1), padding=(0, 1))\n",
      "      (_residual_convolution): Conv2d(1, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (_layer_norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "    )\n",
      "    (1): ASTGCNBlock(\n",
      "      (_temporal_attention): TemporalAttention()\n",
      "      (_spatial_attention): SpatialAttention()\n",
      "      (_chebconv_attention): ChebConvAttention(64, 64, K=3, normalization=None)\n",
      "      (_time_convolution): Conv2d(64, 64, kernel_size=(1, 3), stride=(1, 1), padding=(0, 1))\n",
      "      (_residual_convolution): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (_layer_norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "    )\n",
      "  )\n",
      "  (_final_conv): Conv2d(12, 12, kernel_size=(1, 64), stride=(1, 1))\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "nb_block = 2\n",
    "in_channels = 1\n",
    "K = 3\n",
    "nb_chev_filter = 64\n",
    "nb_time_filter = 64\n",
    "time_strides = num_of_hours\n",
    "num_for_predict = 12\n",
    "len_input = 12\n",
    "#L_tilde = scaled_Laplacian(adj_mx)\n",
    "#cheb_polynomials = [torch.from_numpy(i).type(torch.FloatTensor).to(DEVICE) for i in cheb_polynomial(L_tilde, K)]\n",
    "net = ASTGCN( nb_block, in_channels, K, nb_chev_filter, nb_time_filter, time_strides, num_for_predict, len_input, num_of_vertices).to(DEVICE)\n",
    "\n",
    "print(net)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:40:23.405828Z",
     "iopub.status.busy": "2022-01-02T19:40:23.405002Z",
     "iopub.status.idle": "2022-01-02T19:40:23.477384Z",
     "shell.execute_reply": "2022-01-02T19:40:23.476281Z",
     "shell.execute_reply.started": "2022-01-02T18:28:25.222439Z"
    },
    "papermill": {
     "duration": 0.101833,
     "end_time": "2022-01-02T19:40:23.477478",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.375645",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net's state_dict:\n",
      "_blocklist.0._temporal_attention._U1 \t torch.Size([307]) \t cuda:0\n",
      "_blocklist.0._temporal_attention._U2 \t torch.Size([1, 307]) \t cuda:0\n",
      "_blocklist.0._temporal_attention._U3 \t torch.Size([1]) \t cuda:0\n",
      "_blocklist.0._temporal_attention._be \t torch.Size([1, 12, 12]) \t cuda:0\n",
      "_blocklist.0._temporal_attention._Ve \t torch.Size([12, 12]) \t cuda:0\n",
      "_blocklist.0._spatial_attention._W1 \t torch.Size([12]) \t cuda:0\n",
      "_blocklist.0._spatial_attention._W2 \t torch.Size([1, 12]) \t cuda:0\n",
      "_blocklist.0._spatial_attention._W3 \t torch.Size([1]) \t cuda:0\n",
      "_blocklist.0._spatial_attention._bs \t torch.Size([1, 307, 307]) \t cuda:0\n",
      "_blocklist.0._spatial_attention._Vs \t torch.Size([307, 307]) \t cuda:0\n",
      "_blocklist.0._chebconv_attention._weight \t torch.Size([3, 1, 64]) \t cuda:0\n",
      "_blocklist.0._chebconv_attention._bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.0._time_convolution.weight \t torch.Size([64, 64, 1, 3]) \t cuda:0\n",
      "_blocklist.0._time_convolution.bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.0._residual_convolution.weight \t torch.Size([64, 1, 1, 1]) \t cuda:0\n",
      "_blocklist.0._residual_convolution.bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.0._layer_norm.weight \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.0._layer_norm.bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._temporal_attention._U1 \t torch.Size([307]) \t cuda:0\n",
      "_blocklist.1._temporal_attention._U2 \t torch.Size([64, 307]) \t cuda:0\n",
      "_blocklist.1._temporal_attention._U3 \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._temporal_attention._be \t torch.Size([1, 12, 12]) \t cuda:0\n",
      "_blocklist.1._temporal_attention._Ve \t torch.Size([12, 12]) \t cuda:0\n",
      "_blocklist.1._spatial_attention._W1 \t torch.Size([12]) \t cuda:0\n",
      "_blocklist.1._spatial_attention._W2 \t torch.Size([64, 12]) \t cuda:0\n",
      "_blocklist.1._spatial_attention._W3 \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._spatial_attention._bs \t torch.Size([1, 307, 307]) \t cuda:0\n",
      "_blocklist.1._spatial_attention._Vs \t torch.Size([307, 307]) \t cuda:0\n",
      "_blocklist.1._chebconv_attention._weight \t torch.Size([3, 64, 64]) \t cuda:0\n",
      "_blocklist.1._chebconv_attention._bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._time_convolution.weight \t torch.Size([64, 64, 1, 3]) \t cuda:0\n",
      "_blocklist.1._time_convolution.bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._residual_convolution.weight \t torch.Size([64, 64, 1, 1]) \t cuda:0\n",
      "_blocklist.1._residual_convolution.bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._layer_norm.weight \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._layer_norm.bias \t torch.Size([64]) \t cuda:0\n",
      "_final_conv.weight \t torch.Size([12, 12, 1, 64]) \t cuda:0\n",
      "_final_conv.bias \t torch.Size([12]) \t cuda:0\n",
      "Net's total params: 450159\n",
      "Optimizer's state_dict:\n",
      "state \t {}\n",
      "param_groups \t [{'lr': 0.001, 'betas': (0.9, 0.999), 'eps': 1e-08, 'weight_decay': 0, 'amsgrad': False, 'params': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37]}]\n"
     ]
    }
   ],
   "source": [
    "#------------------------------------------------------\n",
    "learning_rate = 0.001\n",
    "optimizer = optim.Adam(net.parameters(), lr=learning_rate)\n",
    "\n",
    "print('Net\\'s state_dict:')\n",
    "total_param = 0\n",
    "for param_tensor in net.state_dict():\n",
    "    print(param_tensor, '\\t', net.state_dict()[param_tensor].size(), '\\t', net.state_dict()[param_tensor].device)\n",
    "    total_param += np.prod(net.state_dict()[param_tensor].size())\n",
    "print('Net\\'s total params:', total_param)\n",
    "#--------------------------------------------------\n",
    "print('Optimizer\\'s state_dict:')\n",
    "for var_name in optimizer.state_dict():\n",
    "    print(var_name, '\\t', optimizer.state_dict()[var_name])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.022902,
     "end_time": "2022-01-02T19:40:23.523502",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.500600",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Defining the loss function\n",
    "\n",
    " 1. masked_mae"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:40:23.576234Z",
     "iopub.status.busy": "2022-01-02T19:40:23.575651Z",
     "iopub.status.idle": "2022-01-02T19:40:23.578576Z",
     "shell.execute_reply": "2022-01-02T19:40:23.578129Z",
     "shell.execute_reply.started": "2022-01-02T18:28:25.30646Z"
    },
    "papermill": {
     "duration": 0.032533,
     "end_time": "2022-01-02T19:40:23.578674",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.546141",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def masked_mae(preds, labels, null_val=np.nan):\n",
    "    if np.isnan(null_val):\n",
    "        mask = ~torch.isnan(labels)\n",
    "    else:\n",
    "        mask = (labels != null_val)\n",
    "    mask = mask.float()\n",
    "    mask /= torch.mean((mask))\n",
    "    mask = torch.where(torch.isnan(mask), torch.zeros_like(mask), mask)\n",
    "    loss = torch.abs(preds - labels)\n",
    "    loss = loss * mask\n",
    "    loss = torch.where(torch.isnan(loss), torch.zeros_like(loss), loss)\n",
    "    return torch.mean(loss)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:40:23.631622Z",
     "iopub.status.busy": "2022-01-02T19:40:23.630916Z",
     "iopub.status.idle": "2022-01-02T19:40:23.633318Z",
     "shell.execute_reply": "2022-01-02T19:40:23.633709Z",
     "shell.execute_reply.started": "2022-01-02T18:28:25.318709Z"
    },
    "papermill": {
     "duration": 0.032116,
     "end_time": "2022-01-02T19:40:23.633813",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.601697",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "masked_flag=0\n",
    "criterion = nn.L1Loss().to(DEVICE)\n",
    "criterion_masked = masked_mae\n",
    "loss_function = 'mse'\n",
    "\n",
    "metric_method = 'unmask'\n",
    "missing_value=0.0\n",
    "\n",
    "\n",
    "if loss_function=='masked_mse':\n",
    "    criterion_masked = masked_mse         #nn.MSELoss().to(DEVICE)\n",
    "    masked_flag=1\n",
    "elif loss_function=='masked_mae':\n",
    "    criterion_masked = masked_mae\n",
    "    masked_flag = 1\n",
    "elif loss_function == 'mae':\n",
    "    criterion = nn.L1Loss().to(DEVICE)\n",
    "    masked_flag = 0\n",
    "elif loss_function == 'rmse':\n",
    "    criterion = nn.MSELoss().to(DEVICE)\n",
    "    masked_flag= 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:40:23.689145Z",
     "iopub.status.busy": "2022-01-02T19:40:23.687551Z",
     "iopub.status.idle": "2022-01-02T19:40:23.692588Z",
     "shell.execute_reply": "2022-01-02T19:40:23.692111Z",
     "shell.execute_reply.started": "2022-01-02T18:28:25.330842Z"
    },
    "papermill": {
     "duration": 0.036068,
     "end_time": "2022-01-02T19:40:23.692677",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.656609",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def compute_val_loss_mstgcn(net, val_loader, criterion,  masked_flag,missing_value,sw, epoch, edge_index_data, limit=None):\n",
    "    '''\n",
    "    for rnn, compute mean loss on validation set\n",
    "    :param net: model\n",
    "    :param val_loader: torch.utils.data.utils.DataLoader\n",
    "    :param criterion: torch.nn.MSELoss\n",
    "    :param sw: tensorboardX.SummaryWriter\n",
    "    :param global_step: int, current global_step\n",
    "    :param limit: int,\n",
    "    :return: val_loss\n",
    "    '''\n",
    "    net.train(False)  # ensure dropout layers are in evaluation mode\n",
    "    with torch.no_grad():\n",
    "        val_loader_length = len(val_loader)  # nb of batch\n",
    "        tmp = []  # batch loss\n",
    "        for batch_index, batch_data in enumerate(val_loader):\n",
    "            encoder_inputs, labels = batch_data\n",
    "            outputs = net(encoder_inputs, edge_index_data)\n",
    "            if masked_flag:\n",
    "                loss = criterion(outputs, labels, missing_value)\n",
    "            else:\n",
    "                loss = criterion(outputs, labels)\n",
    "            tmp.append(loss.item())\n",
    "            if batch_index % 100 == 0:\n",
    "                print('validation batch %s / %s, loss: %.2f' % (batch_index + 1, val_loader_length, loss.item()))\n",
    "            if (limit is not None) and batch_index >= limit:\n",
    "                break\n",
    "\n",
    "        validation_loss = sum(tmp) / len(tmp)\n",
    "        sw.add_scalar('validation_loss', validation_loss, epoch)\n",
    "    return validation_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:40:23.742334Z",
     "iopub.status.busy": "2022-01-02T19:40:23.741680Z",
     "iopub.status.idle": "2022-01-02T19:40:23.744495Z",
     "shell.execute_reply": "2022-01-02T19:40:23.744059Z",
     "shell.execute_reply.started": "2022-01-02T18:28:25.345232Z"
    },
    "papermill": {
     "duration": 0.029214,
     "end_time": "2022-01-02T19:40:23.744592",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.715378",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "global_step = 0\n",
    "best_epoch = 0\n",
    "best_val_loss = np.inf\n",
    "start_time= time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:40:23.803932Z",
     "iopub.status.busy": "2022-01-02T19:40:23.799125Z",
     "iopub.status.idle": "2022-01-02T19:59:10.338743Z",
     "shell.execute_reply": "2022-01-02T19:59:10.337710Z",
     "shell.execute_reply.started": "2022-01-02T18:28:25.35627Z"
    },
    "papermill": {
     "duration": 1126.571255,
     "end_time": "2022-01-02T19:59:10.338875",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.767620",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "validation batch 1 / 107, loss: 277.87\n",
      "validation batch 101 / 107, loss: 334.15\n",
      "save parameters to file: ./epoch_0.params\n",
      "global step: 200, training loss: 103.08, time: 38.94s\n",
      "validation batch 1 / 107, loss: 54.61\n",
      "validation batch 101 / 107, loss: 83.22\n",
      "save parameters to file: ./epoch_1.params\n",
      "global step: 400, training loss: 39.34, time: 77.39s\n",
      "global step: 600, training loss: 26.75, time: 108.20s\n",
      "validation batch 1 / 107, loss: 39.82\n",
      "validation batch 101 / 107, loss: 43.75\n",
      "save parameters to file: ./epoch_2.params\n",
      "global step: 800, training loss: 27.49, time: 146.22s\n",
      "validation batch 1 / 107, loss: 33.06\n",
      "validation batch 101 / 107, loss: 36.45\n",
      "save parameters to file: ./epoch_3.params\n",
      "global step: 1000, training loss: 26.49, time: 184.33s\n",
      "global step: 1200, training loss: 26.64, time: 215.03s\n",
      "validation batch 1 / 107, loss: 28.73\n",
      "validation batch 101 / 107, loss: 34.21\n",
      "save parameters to file: ./epoch_4.params\n",
      "global step: 1400, training loss: 23.15, time: 253.47s\n",
      "validation batch 1 / 107, loss: 28.88\n",
      "validation batch 101 / 107, loss: 33.24\n",
      "save parameters to file: ./epoch_5.params\n",
      "global step: 1600, training loss: 26.00, time: 291.49s\n",
      "global step: 1800, training loss: 20.62, time: 322.22s\n",
      "validation batch 1 / 107, loss: 27.75\n",
      "validation batch 101 / 107, loss: 32.38\n",
      "save parameters to file: ./epoch_6.params\n",
      "global step: 2000, training loss: 21.06, time: 360.26s\n",
      "global step: 2200, training loss: 21.80, time: 390.96s\n",
      "validation batch 1 / 107, loss: 27.43\n",
      "validation batch 101 / 107, loss: 32.48\n",
      "global step: 2400, training loss: 19.55, time: 428.93s\n",
      "validation batch 1 / 107, loss: 27.28\n",
      "validation batch 101 / 107, loss: 32.15\n",
      "global step: 2600, training loss: 21.54, time: 467.05s\n",
      "global step: 2800, training loss: 19.25, time: 497.67s\n",
      "validation batch 1 / 107, loss: 28.14\n",
      "validation batch 101 / 107, loss: 31.68\n",
      "save parameters to file: ./epoch_9.params\n",
      "global step: 3000, training loss: 23.09, time: 535.62s\n",
      "validation batch 1 / 107, loss: 28.35\n",
      "validation batch 101 / 107, loss: 31.51\n",
      "save parameters to file: ./epoch_10.params\n",
      "global step: 3200, training loss: 19.72, time: 573.80s\n",
      "global step: 3400, training loss: 21.37, time: 604.43s\n",
      "validation batch 1 / 107, loss: 28.92\n",
      "validation batch 101 / 107, loss: 31.78\n",
      "global step: 3600, training loss: 20.88, time: 642.30s\n",
      "global step: 3800, training loss: 20.98, time: 672.92s\n",
      "validation batch 1 / 107, loss: 28.47\n",
      "validation batch 101 / 107, loss: 31.58\n",
      "global step: 4000, training loss: 17.25, time: 710.76s\n",
      "validation batch 1 / 107, loss: 27.29\n",
      "validation batch 101 / 107, loss: 31.51\n",
      "save parameters to file: ./epoch_13.params\n",
      "global step: 4200, training loss: 19.48, time: 748.75s\n",
      "global step: 4400, training loss: 19.07, time: 779.38s\n",
      "validation batch 1 / 107, loss: 26.81\n",
      "validation batch 101 / 107, loss: 31.57\n",
      "save parameters to file: ./epoch_14.params\n",
      "global step: 4600, training loss: 19.82, time: 817.15s\n",
      "validation batch 1 / 107, loss: 27.52\n",
      "validation batch 101 / 107, loss: 31.10\n",
      "global step: 4800, training loss: 19.51, time: 854.94s\n",
      "global step: 5000, training loss: 18.88, time: 885.64s\n",
      "validation batch 1 / 107, loss: 26.25\n",
      "validation batch 101 / 107, loss: 31.66\n",
      "save parameters to file: ./epoch_16.params\n",
      "global step: 5200, training loss: 17.55, time: 923.73s\n",
      "global step: 5400, training loss: 19.11, time: 954.32s\n",
      "validation batch 1 / 107, loss: 26.75\n",
      "validation batch 101 / 107, loss: 31.25\n",
      "save parameters to file: ./epoch_17.params\n",
      "global step: 5600, training loss: 20.55, time: 992.44s\n",
      "validation batch 1 / 107, loss: 28.01\n",
      "validation batch 101 / 107, loss: 31.65\n",
      "global step: 5800, training loss: 19.17, time: 1030.51s\n",
      "global step: 6000, training loss: 19.34, time: 1061.23s\n",
      "validation batch 1 / 107, loss: 26.85\n",
      "validation batch 101 / 107, loss: 31.14\n",
      "global step: 6200, training loss: 15.75, time: 1099.14s\n"
     ]
    }
   ],
   "source": [
    "# train model\n",
    "for epoch in range(20):\n",
    "    params_filename = os.path.join('./', 'epoch_%s.params' % epoch)\n",
    "    masked_flag = 1\n",
    "    if masked_flag:\n",
    "        val_loss = compute_val_loss_mstgcn(net, val_loader, criterion_masked, masked_flag,missing_value,sw, epoch,edge_index_data)\n",
    "    else:\n",
    "        val_loss = compute_val_loss_mstgcn(net, val_loader, criterion, masked_flag, missing_value, sw, epoch,edge_index_data)\n",
    "\n",
    "    if val_loss < best_val_loss:\n",
    "        best_val_loss = val_loss\n",
    "        best_epoch = epoch\n",
    "        torch.save(net.state_dict(), params_filename)\n",
    "        print('save parameters to file: %s' % params_filename)\n",
    "\n",
    "    net.train()  # ensure dropout layers are in train mode\n",
    "\n",
    "    for batch_index, batch_data in enumerate(train_loader):\n",
    "        encoder_inputs, labels = batch_data   # encoder_inputs torch.Size([32, 307, 1, 12])  label torch.Size([32, 307, 12])\n",
    "        optimizer.zero_grad()\n",
    "        outputs = net(encoder_inputs, edge_index_data) # torch.Size([32, 307, 12])\n",
    "\n",
    "        if masked_flag:\n",
    "            loss = criterion_masked(outputs, labels,missing_value)\n",
    "        else :\n",
    "            loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        training_loss = loss.item()\n",
    "        global_step += 1\n",
    "        sw.add_scalar('training_loss', training_loss, global_step)\n",
    "\n",
    "        if global_step % 200 == 0:\n",
    "            print('global step: %s, training loss: %.2f, time: %.2fs' % (global_step, training_loss, time() - start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:59:10.440440Z",
     "iopub.status.busy": "2022-01-02T19:59:10.439599Z",
     "iopub.status.idle": "2022-01-02T19:59:17.814110Z",
     "shell.execute_reply": "2022-01-02T19:59:17.813193Z",
     "shell.execute_reply.started": "2022-01-02T18:37:52.923325Z"
    },
    "papermill": {
     "duration": 7.428189,
     "end_time": "2022-01-02T19:59:17.814238",
     "exception": false,
     "start_time": "2022-01-02T19:59:10.386049",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test_loss batch 1 / 107, loss: 15.12\n",
      "test_loss batch 101 / 107, loss: 29.40\n",
      "21.99220495580513\n"
     ]
    }
   ],
   "source": [
    "net.train(False)  # ensure dropout layers are in evaluation mode\n",
    "with torch.no_grad():\n",
    "    test_loader_length = len(test_loader)  # nb of batch\n",
    "    tmp = []  # batch loss\n",
    "    for batch_index, batch_data in enumerate(test_loader):\n",
    "        encoder_inputs, labels = batch_data\n",
    "        outputs = net(encoder_inputs, edge_index_data)\n",
    "        loss = criterion(outputs, labels)\n",
    "        tmp.append(loss.item())\n",
    "        if batch_index % 100 == 0:\n",
    "            print('test_loss batch %s / %s, loss: %.2f' % (batch_index + 1, test_loader_length, loss.item()))\n",
    "\n",
    "\n",
    "    test_loss = sum(tmp) / len(tmp)\n",
    "    sw.add_scalar('test_loss', test_loss, epoch)\n",
    "print(test_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.046401,
     "end_time": "2022-01-02T19:59:17.907126",
     "exception": false,
     "start_time": "2022-01-02T19:59:17.860725",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Pickig a random time point and visualizing the predictions of the first 50 detectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:59:18.005715Z",
     "iopub.status.busy": "2022-01-02T19:59:18.004506Z",
     "iopub.status.idle": "2022-01-02T19:59:18.008391Z",
     "shell.execute_reply": "2022-01-02T19:59:18.008816Z",
     "shell.execute_reply.started": "2022-01-02T18:48:36.424045Z"
    },
    "papermill": {
     "duration": 0.055894,
     "end_time": "2022-01-02T19:59:18.008925",
     "exception": false,
     "start_time": "2022-01-02T19:59:17.953031",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([307, 12]) torch.Size([307, 12])\n"
     ]
    }
   ],
   "source": [
    "sample_output = outputs[0]  # prediction\n",
    "sample_labels = labels[0] # truth\n",
    "print(sample_output.shape, sample_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:59:18.109257Z",
     "iopub.status.busy": "2022-01-02T19:59:18.108459Z",
     "iopub.status.idle": "2022-01-02T19:59:18.390596Z",
     "shell.execute_reply": "2022-01-02T19:59:18.390081Z",
     "shell.execute_reply.started": "2022-01-02T18:48:36.795997Z"
    },
    "papermill": {
     "duration": 0.335176,
     "end_time": "2022-01-02T19:59:18.390710",
     "exception": false,
     "start_time": "2022-01-02T19:59:18.055534",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2400x320 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.pyplot import figure\n",
    "\n",
    "figure(figsize=(30,4), dpi=80)\n",
    "for i in range(50):\n",
    "    new_i = i * 12\n",
    "    plt.plot(range(0+new_i,12+new_i),sample_output[i].detach().cpu().numpy(), color = 'red')\n",
    "    plt.plot(range(0+new_i,12+new_i),sample_labels[i].cpu().numpy(), color='blue')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "papermill": {
     "duration": 0.049622,
     "end_time": "2022-01-02T19:59:18.489086",
     "exception": false,
     "start_time": "2022-01-02T19:59:18.439464",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "papermill": {
   "duration": 1234.454996,
   "end_time": "2022-01-02T19:59:18.744009",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2022-01-02T19:38:44.289013",
   "version": "2.1.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
